package xyz.wbsite.dbtool.javafx.tool;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

public class FileUtil {

    public static List<String> readFileToLines(File filePath) {
        return readFileToLines(filePath.getAbsolutePath());
    }

    public static List<String> readFileToLines(String fileName) {
        List<String> returnString = new ArrayList<String>();
        File file = new File(fileName);
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));
            String tempString = null;
            int line = 1;
            // 一次读入一行，直到读入null为文件结束
            while ((tempString = reader.readLine()) != null) {
                // 显示行号
                returnString.add(tempString);
                line++;
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }
        return returnString;
    }

    public static String readFileToString(File file) throws IOException {
        byte[] bytes = readFileToByteArray(file);
        return new String(bytes, "UTF-8");
    }

    public static byte[] readFileToByteArray(File file) throws IOException {
        InputStream in = openInputStream(file);
        Throwable var2 = null;

        byte[] var5;
        try {
            long fileLength = file.length();
            var5 = fileLength > 0L ? toByteArray(in, fileLength) : toByteArray(in);
        } catch (Throwable var14) {
            var2 = var14;
            throw var14;
        } finally {
            if (in != null) {
                if (var2 != null) {
                    try {
                        in.close();
                    } catch (Throwable var13) {
                        var2.addSuppressed(var13);
                    }
                } else {
                    in.close();
                }
            }

        }

        return var5;
    }

    public static boolean writeStringToFile(String data, File file, boolean isNewLine, boolean isAppend) {
        PrintWriter printWriter = null;
        try {
            printWriter = openPrintWriter(file);
            if (isNewLine && isAppend) {// 换行追加
                printWriter.println();
                printWriter.append(data);
            } else if (!isNewLine && isAppend) {// 不换行追加
                printWriter.append(data);
            } else {// 直接写入
                printWriter.print(data);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            if (printWriter != null) printWriter.close();
        }
    }

    public static PrintWriter openPrintWriter(File file) {
        try {
            return new PrintWriter(new FileOutputStream(file));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static FileInputStream openInputStream(File file) throws IOException {
        if (file.exists()) {
            if (file.isDirectory()) {
                throw new IOException("File '" + file + "' exists but is a directory");
            } else if (!file.canRead()) {
                throw new IOException("File '" + file + "' cannot be read");
            } else {
                return new FileInputStream(file);
            }
        } else {
            throw new FileNotFoundException("File '" + file + "' does not exist");
        }
    }

    public static FileOutputStream openOutputStream(File file) throws IOException {
        if (file.exists()) {
            if (file.isDirectory()) {
                throw new IOException("File '" + file + "' exists but is a directory");
            } else if (!file.canRead()) {
                throw new IOException("File '" + file + "' cannot be read");
            } else {
                return new FileOutputStream(file);
            }
        } else {
            throw new FileNotFoundException("File '" + file + "' does not exist");
        }
    }

    /**
     * @param fileLocation 文件路径
     * @return URL
     */
    public static URL getURL(String fileLocation) {
        try {
            return new URL(fileLocation);
        } catch (MalformedURLException var6) {
            try {
                return (new File(fileLocation)).toURI().toURL();
            } catch (MalformedURLException var5) {
                var5.printStackTrace();
            }
        }
        return null;
    }

    public static byte[] toByteArray(InputStream input, long size) throws IOException {
        if (size > 2147483647L) {
            throw new IllegalArgumentException("Size cannot be greater than Integer max value: " + size);
        } else {
            return toByteArray(input, (int) size);
        }
    }

    public static byte[] toByteArray(InputStream input, int size) throws IOException {
        if (size < 0) {
            throw new IllegalArgumentException("Size must be equal or greater than zero: " + size);
        } else if (size == 0) {
            return new byte[0];
        } else {
            byte[] data = new byte[size];

            int offset;
            int read;
            for (offset = 0; offset < size && (read = input.read(data, offset, size - offset)) != -1; offset += read) {
                ;
            }

            if (offset != size) {
                throw new IOException("Unexpected read size. current: " + offset + ", expected: " + size);
            } else {
                return data;
            }
        }
    }

    public static byte[] toByteArray(InputStream input) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        Throwable var2 = null;

        byte[] var3;
        try {
            copy((InputStream) input, (OutputStream) output);
            var3 = output.toByteArray();
        } catch (Throwable var12) {
            var2 = var12;
            throw var12;
        } finally {
            if (output != null) {
                if (var2 != null) {
                    try {
                        output.close();
                    } catch (Throwable var11) {
                        var2.addSuppressed(var11);
                    }
                } else {
                    output.close();
                }
            }

        }

        return var3;
    }

    public static int copy(InputStream input, OutputStream output) throws IOException {
        long count = copyLarge(input, output);
        return count > 2147483647L ? -1 : (int) count;
    }

    public static boolean copy(File in, File out) throws Exception {
        try {
            FileInputStream input = new FileInputStream(in);
            FileOutputStream output = new FileOutputStream(out);
            copy(input, output);
            input.close();
            output.close();
            return true;
        } catch (IOException ie) {
            return false;
        }
    }

    public static long copyLarge(InputStream input, OutputStream output) throws IOException {
        return copy(input, output, 4096);
    }

    public static long copy(InputStream input, OutputStream output, int bufferSize) throws IOException {
        return copyLarge(input, output, new byte[bufferSize]);
    }

    public static long copyLarge(InputStream input, OutputStream output, byte[] buffer) throws IOException {
        long count;
        int n;
        for (count = 0L; -1 != (n = input.read(buffer)); count += (long) n) {
            output.write(buffer, 0, n);
        }

        return count;
    }

    public static boolean clearDirectory(File dir) {
        if ((dir == null) || !dir.isDirectory()) {
            throw new IllegalArgumentException("Argument " + dir +
                    " is not a directory. ");
        }

        File[] entries = dir.listFiles();
        int sz = entries.length;

        for (int i = 0; i < sz; i++) {
            if (entries[i].isDirectory()) {
                if (!clearDirectory(entries[i])) {
                    return false;
                }
            } else {
                if (!entries[i].delete()) {
                    return false;
                }
            }
        }

        if (!dir.delete()) {
            return false;
        }
        return true;
    }

    /**
     * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
     * 其实就是将路径中的"\"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，
     * 某中程度上说"/"比"\"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。
     */
    public static String toUNIXpath(String filePath) {
        return filePath.replace('\\', '/');
    }

    public static void inputStream2File(InputStream is, File target) {
        try {
            if (!target.exists() && !target.createNewFile()) {
                throw new RuntimeException(target.getName() + "not exists");
            }
            OutputStream outStream = new FileOutputStream(target);
            byte[] buffer = new byte[8 * 1024];
            int bytesRead;
            while ((bytesRead = is.read(buffer)) != -1) {
                outStream.write(buffer, 0, bytesRead);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
